import java.util.Vector;
import java.io.Serializable;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Observable;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
 * Classe controleur et application (système)
 * @author IUT,   A. Culet
 * @version 1.0 
 */


public class Controleur extends Observable implements Serializable{
//public class Controleur implements Serializable {
	
	private static final long serialVersionUID = 1L;

	/**
	 * La classe Controleur est unique pour tous les cas d'utilisation
	 * Elle est également la classe "application" qui gère l'ensemble des objets de l'appli
	 */	
	// ************************************************************************************************************
		// Attributs
		// ************************************************************************************************************
	
		// Attributs d'Association
		// Ensemble des ouvrages de la bibliothèque
		private HashMap<String, Ouvrage> _ouvrages; 
		
		//Ensemble des auteurs de la bibliothèque
		private HashMap<String, Auteur> _auteurs;
		
		//Ensemble des periodiques de la bibliothèque
		private HashMap<String, Periodique> _periodiques;
		
		//Ensemble des periodiques de la bibliothèque
		private HashMap<String, MotsCles> _motscles;
		
		// les différentes fenêtres pour chaque fonctionnalité
		private VueMenuBiblio _vueMenuBiblio = null;
		
		// une seule fenêtre est active à la fois; les autres sont à null.
		// permet de connaître l'état des fenêtres de l'interface
		private VueSaisieOuvrage _vueSaisieOuvrage = null;
		private VueSaisieExemplaire _vueSaisieExemplaire = null;
		private VueConsultOuvrage _vueConsultOuvrage = null;
		private VueConsultPeriodique _vueConsultPeriodique = null;
		private VueSaisieParution _vueSaisieParution = null;
		private VueSaisiePeriodique _vueSaisiePeriodique = null;
		private VueRechercheMotCle _vueRechercheMotCle = null;
		private VueRechercheParAuteur _vueRechercheParAuteur = null;
		
		// ************************************************************************************************************
		// Constructeur
		// ************************************************************************************************************

		public Controleur() {
			this.setOuvrages(new HashMap<String, Ouvrage>());
			this.setPeriodiques(new HashMap<String, Periodique>());
			this.setAuteurs(new HashMap<String,Auteur>());
			this.setMotsCles(lectureLignesFichierAutorite());
		} // Fin Controleur

		// ************************************************************************************************************
		// Méthodes privées
		// ************************************************************************************************************

		// ------------------------------------------------------------------------------------------------------------
		// Affecteurs
		
		/**
		 * Ajoute un ouvrage à l'ensemble des ouvrages de la bibliothèque.
		 * @param ouvrage 	Ouvrage à ajouter
		 * @param isbn 	code ISBN de cet ouvrage
		 */
		private void setOuvrage(Ouvrage ouvrage, String isbn) {
			this.getOuvrages().put(isbn, ouvrage);
		} // Fin setOuvrage
		
		private void setPeriodique(Periodique periodique, String issn) {
			this.getPeriodiques().put(issn, periodique);
		} // Fin setPeriodique

		/**
		 * @param ouvrages hashtable d'ouvrages à affecter
		 */
		private void setOuvrages(HashMap<String, Ouvrage> ouvrages) {
			_ouvrages = ouvrages;
		}// Fin setOuvrages
		
		/**
		 * @param periodiques hashtable de periodiques à affecter
		 */
		private void setPeriodiques(HashMap<String, Periodique> periodiques) {
			_periodiques = periodiques;
		}// Fin setOuvrages
		
		private void setMotsCles(HashMap<String, MotsCles> motscles) {
			_motscles = motscles;
		}// Fin setMotsCles
		
		//setteur de auteurs
		private void setAuteurs(HashMap<String, Auteur> auteurs) {
			_auteurs = auteurs;
		}// Fin setAuteurs
		
		private void setAuteur(Auteur a) {
			_auteurs.put(a.getNom(),a);
		}
		
		/**
		 * @param vue  la vue à affecter
		 */
		private void setVueMenuBiblio(VueMenuBiblio vue) {
			_vueMenuBiblio = vue;
		}// Fin getVueVueMenuBiblio
		
		private void setVueSaisieOuvrage(VueSaisieOuvrage vue) {
			_vueSaisieOuvrage = vue;
		}// Fin setVueVueSaisieOuvrage
		
		private void setVueSaisieExemplaire(VueSaisieExemplaire vue) {
			_vueSaisieExemplaire = vue;
		}// Fin setVueVueSaisieExemplaire
		
		private void setVueConsultOuvrage(VueConsultOuvrage vue) {
			_vueConsultOuvrage = vue;
		}// Fin setVueVueConsultOuvrage
		
		private void setVueConsultPeriodique(VueConsultPeriodique vue) {
			_vueConsultPeriodique = vue;
		}// Fin setVueVueSaisieExemplaire
		
		private void setVueSaisieParution(VueSaisieParution vue) {
			_vueSaisieParution = vue;
		}// Fin setVueVueSaisieExemplaire
		
		private void setVueSaisiePeriodique(VueSaisiePeriodique vue) {
			_vueSaisiePeriodique = vue;
		}// Fin setVueVueSaisiePeriodique
		
		private void setVueRechercheMotCle(VueRechercheMotCle vue) {
			_vueRechercheMotCle = vue;
		}

		private void setVueRechercheParAuteur(VueRechercheParAuteur vue) {
			_vueRechercheParAuteur = vue;
		}
		// ------------------------------------------------------------------------------------------------------------
		// Accesseurs
		

		public HashMap<String, MotsCles> lectureLignesFichierAutorite(){
			HashMap<String, MotsCles> MotsCles=new HashMap<String, MotsCles>();
			try  {
				BufferedReader in = new BufferedReader(
							new FileReader("ListeAutorite.txt"));
				String ligne;
				while ((ligne= in.readLine()) != null)  {
					MotsCles m=new MotsCles(ligne);
					MotsCles.put(ligne, m);
				}
				in.close();
				return MotsCles;
			}
			catch (IOException e) {
			 	System.out.println("$$$$$ PB de Lecture dans le fichier XXXXX ");
				System.out.println();
				return MotsCles;
			}
			}

		
		/**
		 * @return ensemble des ouvrages de la bibliothèque
		 */
		private HashMap<String, Ouvrage> getOuvrages() {
			return _ouvrages;
		}// Fin getOuvrages

		/**
		 * @return ensemble des périodiques de la bibliothèque
		 */
		private HashMap<String, Periodique> getPeriodiques() {
			return _periodiques;
		}// Fin getPeriodiques
		
		/**
		 * Accès à un ouvrage par son numéro ISBN
		 * @param isbn 	le code ISBN de l'ouvrage cherché
		 * @return l'ouvrage qui a l'ISBN indiqué
		 */
		private Ouvrage getOuvrage(String isbn) {
			return this.getOuvrages().get(isbn);
		} // Fin getOuvrage
		
		public Ouvrage getOuvrageIsbn(String isbn) {
			return this.getOuvrages().get(isbn);
		} // Fin getOuvrage
		
		public Auteur rechAuteur(String nom, String prenom){
			//recherche si l'auteur est dans la base de donnée
			Auteur a=this.getAuteur(nom,prenom);
			if (this.getVueSaisieOuvrage() != null) {
				//si la vue est saisie ouvrage creation de l'auteur et ajout dans le controlleur
				if(a==null){
					a=new Auteur(nom,prenom);
					this.setAuteur(a);
				}
			}
			return a;
		}
		
		public Auteur getAuteur(String nom, String prenom){
			//recherche si l'auteur est enregistré au controleur
			Auteur a = new Auteur(nom,prenom);
			Auteur b = null;
			if(_auteurs!=null)
			{
//				for (Auteur aut : _auteurs.values()){
//					if (aut.equals(a))
//						b = aut;
//				}
//				return b;
				
				return (_auteurs.get(nom));
//				if(_auteurs.containsValue(a)){
//					return a;
//				}
//				else
//				{
//					return null;
//				}
			}
			else
			{
				return null;
			}
		}
		
		Periodique getPeriodique(String issn) 
		{
			return _periodiques.get(issn);
		}// Fin getPeriodique
		
		public void lierAuteur(Auteur a){
			if(_auteurs==null){
				_auteurs= new HashMap<String,Auteur>();
			}
			_auteurs.put(a.getNom(),a);
		}
		
		public MotsCles getMotCle(String mot){
			//renvoi l'objet de mot cles associé au mot
			return(_motscles.get(mot));
		}
		
		public Auteur getAuteur(String auteur){
			//renvoi l'objet de auteur associé à l'auteur
			return(_auteurs.get(auteur));
		}
		
		
		public Parution getParu(String issn, String numero ){
			//renvoi l'objet de Parution associé a l'isbn et au numero
			Periodique period = getPeriodique(issn);
			if(this.getVueSaisieParution()!=null)
				period.addObserver(_vueSaisieParution);
			Parution p = period.getParution(numero);
			return p;
		}
		
		public HashMap<String, Auteur> rechAuteurs(){
			//methode public recherchant tout les auteurs
			/*Auteur a=new Auteur("momo","bobo");
			HashMap<String,Auteur>auteurs;
			auteurs=new HashMap<String,Auteur>();
			auteurs.put("momo",a);
			this.setAuteurs(auteurs);*/
			HashMap<String, Auteur> Auteurs= this.getAuteurs();
			return Auteurs;
		}
		
		public HashMap<String, MotsCles> rechMotsCles(){
			//methode public recherchant tout les mots cles
			//this.setMotsCles(lectureLignesFichierAutorite());
			HashMap<String, MotsCles> motscles= this.getMotsCles();
			return motscles;
		}
		
		public HashMap<String, Periodique> rechPeriodiques(){
			//methode public recherchant tout les mots cles
			HashMap<String, Periodique> periodiques= this.getPeriodique();
			return periodiques;
		}
		
		public Periodique rechPeriodique(String issn){
			for(Periodique p : _periodiques.values()){
				if(p.getIssn()==issn){
					return p;
				}
			}
			return null;
		}
		
		private HashMap<String, Periodique> getPeriodique(){
			//methode privée recherchant tout les auteurs, appelé par rechAuteurs
			return _periodiques;
		}
		
		private HashMap<String, Auteur> getAuteurs(){
			//methode privée recherchant tout les auteurs, appelé par rechAuteurs
			return _auteurs;
		}
		
		
		private HashMap<String, MotsCles> getMotsCles(){
			//methode privée recherchant tout les auteurs, appelé par rechAuteurs
			return _motscles;
		}
		/**
		 * @return la vue  
		 */
		private VueMenuBiblio getVueMenuBiblio() {
			return _vueMenuBiblio ;
		}// Fin getVueMenuBiblio
		
		private VueSaisieOuvrage getVueSaisieOuvrage() {
			return _vueSaisieOuvrage ;
		}// Fin getVueSaisieOuvrage
		
		private VueSaisieExemplaire getVueSaisieExemplaire() {
			return _vueSaisieExemplaire ;
		}// Fin getVueSaisieExemplaire
		
		private VueConsultOuvrage getVueConsultOuvrage() {
			return _vueConsultOuvrage ;
		}// Fin getVueConsultOuvrage
		
		private VueConsultPeriodique getVueConsultPeriodique() {
			return _vueConsultPeriodique ;
		}// Fin getVueConsultPeriodique
		
		private VueSaisieParution getVueSaisieParution() {
			return _vueSaisieParution ;
		}// Fin getVueSaisieExemplaire
		
		private VueSaisiePeriodique getVueSaisiePeriodique() {
			return _vueSaisiePeriodique ;
		}// Fin getVueSaisiePeriodique
		
		
		private VueRechercheMotCle getVueRechercheMotCle() {
			return _vueRechercheMotCle ;
		}// Fin getVueVueSaisiePeriodique
		
		private VueRechercheParAuteur getVueRechercheParAuteur() {
			return _vueRechercheParAuteur;
		}// Fin getVueVueSaisiePeriodique
		
		
		// ************************************************************************************************************
		// Méthodes publiques de création et affichage des fenêtres de l'application et fermeture
		// ************************************************************************************************************
		/**
		 * Création et affichage de la fenêtre principale de l'application. 
		 * Elle reste affichée
		 */
		
		//Methode verifiant que chaque champ du vecteur recu est non vide, affiche un message d'erreur sinon
		//false si vide
		public boolean champsVide(Vector<String> vect){
			String s;
			boolean result=true;
			for(int i=0;i<vect.size();i++){
				s=(String)vect.elementAt(i);
				if(s.length()==0){
					Message dialog = new Message("Le champs "+(i+1)+" est vide");
					dialog.setVisible(true);
					result=false;
					break;
				}
			}
			return result;
		}
		
		public boolean dateValide(String dateEdition){
			GregorianCalendar date = ESDate.lireDate (dateEdition);
			if (date == null) 
			{
				Message dialog = new Message("Le format de la date est incorrect");
				dialog.setVisible(true);
				return false;
			}
			else
				return true;
		}
		
		public void menuBiblio() {
			try {this.setVueMenuBiblio(new VueMenuBiblio(this));	
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		/**
		 * Création et affichage de la fenêtre de consultation d'un ouvrage
		 */
		
		public void consulterOuvrage() {
			try {this.setVueConsultOuvrage (new VueConsultOuvrage(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false); 	
			// la vue courante est VueConsultOuvrage
				this.getVueConsultOuvrage().setEtat(Vue.initiale);
				this.getVueConsultOuvrage().setVisible(true);
			} catch (Exception e) {
				e.printStackTrace();
			}	
		}
		
		public void consulterParution() {
			try{this.setVueConsultPeriodique (new VueConsultPeriodique(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false); 
			// la vue courante est VueConsultOuvrage
			this.getVueConsultPeriodique().setEtat(Vue.initiale);
			this.getVueConsultPeriodique().setVisible(true);
			}catch (Exception e) {
				e.printStackTrace();
			}
		}
		
		/**
		 * Création et affichage de la fenêtre de saisie d'un exemplaire d'ouvrage
		 */
		public void saisirExemplaire() {
			try {this.setVueSaisieExemplaire(new VueSaisieExemplaire(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false); 
			// la vue courante est VueSaisieExemplaire
				this.getVueSaisieExemplaire().setEtat(Vue.initiale);
				this.getVueSaisieExemplaire().setVisible(true);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		/**
		 * Création et affichage de la fenêtre de saisie d'un ouvrage
		 */
		public void saisirOuvrage() {
			try {this.setVueSaisieOuvrage(new VueSaisieOuvrage(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false); 
			// la vue courante est VueSaisieOuvrage
				this.getVueSaisieOuvrage().setEtat(Vue.initiale);
				this.getVueSaisieOuvrage().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		
		public void saisirPeriodique(){
			try {this.setVueSaisiePeriodique(new VueSaisiePeriodique(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false); 
			// la vue courante est VueSaisieOuvrage
				this.getVueSaisiePeriodique().setEtat(Vue.initiale);
				this.getVueSaisiePeriodique().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		
		public void saisirParution(){
			try {this.setVueSaisieParution(new VueSaisieParution(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false); 
			// la vue courante est VueSaisieOuvrage
				this.getVueSaisieParution().setEtat(Vue.initiale);
				this.getVueSaisieParution().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		
		public void rechParMotsCles(){
			try {
				this.setVueRechercheMotCle(new VueRechercheMotCle(this));
				// le Menu est caché
				this.getVueMenuBiblio().getFrame().setVisible(false); 
				// la vue courante est VueRechercheMotCle
				this.getVueRechercheMotCle().setEtat(Vue.initiale);
				this.getVueRechercheMotCle().setVisible(true);
			} 
			catch (Exception e) {
				e.printStackTrace();
			}
		}

		public void rechParAuteur()
		{
			try 
			{
				this.setVueRechercheParAuteur(new VueRechercheParAuteur(this));
				// le Menu est caché
				this.getVueMenuBiblio().getFrame().setVisible(false); 
				// la vue courante est VueRechercheParAuteur
				this.getVueRechercheParAuteur().setEtat(Vue.initiale);
				this.getVueRechercheParAuteur().setVisible(true);
			} 
			catch (Exception e) 
			{
				e.printStackTrace();
			}
		}
		
		public void consulterPeriodique()
		{
			try 
			{
				this.setVueConsultPeriodique(new VueConsultPeriodique(this));
				// le Menu est caché
				this.getVueMenuBiblio().getFrame().setVisible(false); 
				// la vue courante est VueRechercheParAuteur
				this.getVueConsultPeriodique().setEtat(Vue.initiale);
				this.getVueConsultPeriodique().setVisible(true);
			} 
			catch (Exception e) 
			{
				e.printStackTrace();
			}
		}
		
		/**
		 * fermeture de la fenêtre vue
		 * lors de la fermeture de la fenêtre principale de l'application sauvegarde des objets sérialisés 
		 */
		public void fermerVue (Vue vue) {
			if (vue instanceof VueMenuBiblio ) {	
			// Quitte l'aplication. Sauvegarde les objets du modèle
				this.sauve();
				System.exit(0);
				}
			vue.dispose();
			// le Menu est rendu de nouveau visible
			this.getVueMenuBiblio().getFrame().setVisible(true);
			this.resetVues();
		}
		
		// Restaure l'état de l'interface avec seule la fenêtre du Menu principal active
		private void resetVues() {
			this.setVueSaisieOuvrage (null);
			this.setVueConsultOuvrage(null);
			this.setVueConsultPeriodique(null);
			this.setVueSaisieExemplaire(null);
			this.setVueSaisieParution(null);
		}
		
		// ************************************************************************************************************
		// Opérations liées à la sérialisation des objets de l'application
		// ************************************************************************************************************
		/**
		 *  restauration des objets de l'application
		 */
		public Controleur restaure() {
			try {
				FileInputStream fichier = new FileInputStream("Fsauv.ser");
				ObjectInputStream in = new ObjectInputStream(fichier);
				return((Controleur) in.readObject());
			} catch (Exception e) {
				Message dialog = new Message("Pbs de Restauration ou fichier non encore créé");
				dialog.setVisible(true);
				return this;
			} 
		}
		/**
		 *  sauvegarde des objets de l'application
		 */
		private void sauve() {
			try {
				FileOutputStream f = new FileOutputStream("Fsauv.ser");
				ObjectOutputStream out = new ObjectOutputStream(f);
				out.writeObject(this);
			} catch (Exception e) {
				Message dialog = new Message("Pb de Sauvegarde dans le fichier");
				dialog.setVisible(true);
			}
		}
		// ************************************************************************************************************
		// Opérations liées à l'application en réponse à une action de l'utilisateur dans une vue
		// ************************************************************************************************************

		/**
		 * Accès à un ouvrage par son numéro ISBN
		 * Invoqué dans VueConsultOuvrage et VueSaisieExemplaire
		 * @param isbn 	le code ISBN de l'ouvrage cherché
		 * @return l'ouvrage qui a l'ISBN indiqué ou null
		 * affiche un message d'erreur si l'ouvrage n'est pas trouvé
		 */
		public Ouvrage rechOuvrage(String isbn) {
			Ouvrage ouv = this.getOuvrage(isbn);
			if (ouv == null) {
				//la vue courrante est vueSaisieOuvrage
				if (this.getVueSaisieOuvrage() != null) {
					if(isbn.length()==0){
						Message dialog = new Message("Vous devez entrez un isbn");
						dialog.setVisible(true);
						}
					else{
						this.getVueSaisieOuvrage().setEtat(Vue.inter1);
					}
				}
				else{
					Message dialog = new Message("Ouvrage inconnu");
					dialog.setVisible(true);
				}
			}
			else {
				if (this.getVueSaisieOuvrage() != null) {
						Message dialog = new Message("L'isbn saisie est déja utilisé");
						dialog.setVisible(true);
						}
				// la vue courante est VueSaisieExemplaire
				if (this.getVueSaisieExemplaire() != null) {
				// la vue est inscrite comme observatrice de l'ouvrage	
					ouv.addObserver(this.getVueSaisieExemplaire());
				// le contrôleur modifie l'état de la vue
					this.getVueSaisieExemplaire().setEtat(Vue.inter1);
					this.getVueSaisieExemplaire().alimente(ouv);
					}
				// la vue courante est VueConsultOuvrage
				if (this.getVueConsultOuvrage() != null) {
					// le contrôleur modifie l'état de la vue
					this.getVueConsultOuvrage().setEtat(Vue.finale);
					this.getVueConsultOuvrage().alimente(ouv);
					}
			}
			return ouv;
		} // Fin rechOuvrage
		
		
		public void alimenteAuteurs(HashMap <String, Auteur> auteurs){
			//pour tout auteurs on alimente la vue si il s'agit de la vue vuesaisieouvrage
			
			if (this.getVueSaisieOuvrage() != null) {
				if(auteurs!=null){
				for (Auteur a : auteurs.values()) {
				  this.getVueSaisieOuvrage().alimente(a);
				}
				}
				this.getVueSaisieOuvrage().setEtat(Vue.inter2);
			}
			if (this.getVueRechercheParAuteur() != null) {
				if(auteurs!=null){
				for (Auteur a : auteurs.values()) {
				  this.getVueRechercheParAuteur().alimente(a);
				}
				}
			}
			if (this.getVueSaisieParution() != null) {
				if(auteurs!=null){
				this.getVueSaisieParution().viderTxtAreaAuteurs();
				for (Auteur a : auteurs.values()) {
				  this.getVueSaisieParution().alimente(a);
				}
				}
				this.getVueSaisieParution().setEtat(Vue.inter3);
			}
			if (this.getVueSaisiePeriodique() != null) {
				if(auteurs!=null){
				this.getVueSaisiePeriodique().viderTxtAreaAuteurs();	
				for (Auteur a : auteurs.values()) {
				  this.getVueSaisiePeriodique().alimente(a);
				}
				}
				this.getVueSaisiePeriodique().setEtat(Vue.inter3);
			}
		}
		
		public void alimenteMotsCles(HashMap <String, MotsCles> motscles){
			//pour tout motscles on alimente la vue si il s'agit de la vue vuesaisieouvrage
			if (this.getVueSaisieOuvrage() != null) {
				if(motscles!=null){
				for (MotsCles m : motscles.values()) {
				  this.getVueSaisieOuvrage().alimente(m);
				}
				}
				this.getVueSaisieOuvrage().setEtat(Vue.inter3);
			}
			if (this.getVueRechercheMotCle() != null) {
				if(motscles!=null){
				for (MotsCles m : motscles.values()) {
				  this.getVueRechercheMotCle().alimente(m);
				}
				}
			}
			if (this.getVueSaisieParution() != null) {
				if(motscles!=null){
				for (MotsCles m : motscles.values()) {
				  this.getVueSaisieParution().alimente(m);
				}
				}
				this.getVueSaisieParution().setEtat(Vue.inter4);
			}
			if (this.getVueSaisiePeriodique() != null) {
				if(motscles!=null){
				for (MotsCles m : motscles.values()) {
				  this.getVueSaisiePeriodique().alimente(m);
				}
				}
				this.getVueSaisiePeriodique().setEtat(Vue.inter4);
			}
		}
		
		public void alimentePeriodiques(HashMap <String, Periodique> periodiques){
			//pour tout auteurs on alimente la vue si il s'agit de la vue vuesaisieouvrage
			if (this.getVueSaisieParution() != null) {
				if(periodiques!=null){
				for (Periodique p : periodiques.values()) {
				  this.getVueSaisieParution().alimente(p);
				}
				}
				this.getVueSaisieParution().setEtat(Vue.initiale);
			}
		}
		
		public void alimenteOuvrageMot(MotsCles mot){
			//pour tout auteurs on alimente la vue si il s'agit de la vue vuesaisieouvrage
			
			if (this.getVueRechercheMotCle() != null) {
				if(mot!=null){
					HashSet<Ouvrage> ouv=mot.getOuvrages();
					if(ouv.isEmpty()){
						this.getVueRechercheMotCle().alimenteOuvrageVide();
					}
					else{
						Iterator<Ouvrage> it = ouv.iterator();
						while (it.hasNext()){
							this.getVueRechercheMotCle().alimente(it.next());
						}
					}
				}
			}
		}

		public void alimenteArticleMot(MotsCles mot){
			//pour l'auteurs on alimente la vue si il s'agit de la vue vuesaisieouvrage
			
			if (this.getVueRechercheMotCle() != null) {
				if(mot!=null){
					HashSet<Article> art=mot.getArticles();
					if(art.isEmpty()){
						this.getVueRechercheMotCle().alimenteArticleVide();
					}
					else{
						Iterator<Article> it = art.iterator();
						while (it.hasNext()){
							this.getVueRechercheMotCle().alimente(it.next());
						}
					}
				}
			}
		}

		public void alimenteArticleAuteur(Auteur aut){
		//pour l'auteur on alimente la vue si il s'agit de la vue VueRechercheParAuteur
			
			if (this.getVueRechercheParAuteur() != null) //verification que la fenêtre est ouverte
			{
				if(aut!=null) //verification que l'auteur n'est pas null
				{
					HashSet<Article> art = aut.getArticles(); //creation de l'ensemble d'article
					if(art.isEmpty())
					{
						// si il n'ya aucun article
						this.getVueRechercheParAuteur().alimenteArticleVide();
					}
					else
					{
						// si il y'a des articles, on les affichent dans une liste
						Iterator<Article> it = art.iterator();
						while (it.hasNext())
						{
							this.getVueRechercheParAuteur().alimente(it.next());
						}
					}
				}
			}
		}

		public void alimenteOuvrageAuteur(Auteur aut){
			//pour un auteur on alimente la vue si il s'agit de la vue VueRechercheParAuteur
			
			if (this.getVueRechercheParAuteur() != null) //verification que la fenêtre est ouverte
			{
				if(aut!=null)//verification que l'auteur n'est pas null
				{
					HashSet<Ouvrage> ouv=aut.getOuvrages();
					if(ouv.isEmpty())
					{
						// si il n'ya aucun ouvrage
						this.getVueRechercheParAuteur().alimenteOuvrageVide();
					}
					else
					// si il y'a des ouvrages, on les affichent dans une liste
					{
						Iterator<Ouvrage> it = ouv.iterator();
						while (it.hasNext())
						{
							this.getVueRechercheParAuteur().alimente(it.next());
						}
					}
				}
			}
		}

		
		
		/**
		 * Création d'un exemplaire d'ouvrage 
		 * Invoqué dans VueSaisieExemplaire
		 * @param ouv l'ouvrage  dateRecep la date de réception de l'exemplaire	
		 * affiche un message de confirmation après l'enregistrement ou un message d'erreur 
		 */
		public void nouvExemplaire(Ouvrage ouv, String dateReception, String statut) {
			// vérification de la présence de la date et de son format
			if (dateReception.length() == 0 ){
					Message dialog = new Message("La date de réception est obligatoire");
					dialog.setVisible(true);
					dialog = new Message("L'exemplaire n'as pas été enregistré.");
					dialog.setVisible(true);
					}
			else {
				GregorianCalendar date = ESDate.lireDate (dateReception);
				if (date == null) {
					Message dialog = new Message("Le format de la date est incorrect");
					dialog.setVisible(true);
					dialog = new Message("L'exemplaire n'as pas été enregistré");
					dialog.setVisible(true);
					}
				else {
					int statutEx;
					if (statut == "empruntable") {
						statutEx = Exemplaire.EMPRUNTABLE ; }
					else {
						statutEx = Exemplaire.EN_CONSULTATION ; }
			// demande d'ajout de l'exemplaire
					Exemplaire exemplaire = ouv.ajouterExemplaire(date, statutEx);
			// l'opération s'est bien passée
					if (exemplaire != null) {
			// le contrôleur modifie l'état de la vue
						if(this.getVueSaisieExemplaire()!=null){
						this.getVueSaisieExemplaire().setEtat(Vue.finale);
						}
						
			// affichage d'un message de confirmation
						Message dialog = new Message("Exemplaire enregistré");
						dialog.setVisible(true);
					}
					else {
						Message dialog = new Message("Date de Reception incorrecte / à la date d'Edition.");
						dialog.setVisible(true);
					}
				}
			}
		}
		
		
		/**
		 * Création d'un  d'ouvrage 
		 * Invoqué dans VueSaisieOuvrage
		 * @param  dateEdition la date d'édition de l'ouvrage
		 * affiche un message de confirmation après l'enregistrement ou un message d'erreur 
		 */
		
	public void nouvOuvrage(String isbn, String titre,String editeur, String dateEdition, HashSet<Auteur> auteursOuvrage, HashSet<MotsCles> motsclesOuvrage) {
			GregorianCalendar date = ESDate.lireDate (dateEdition);
			Ouvrage ouv=new Ouvrage(isbn,titre,editeur,date,auteursOuvrage,motsclesOuvrage);
			this.setOuvrage(ouv, isbn);
			Message dialog = new Message("Ouvrage Enregistré.");
			dialog.setVisible(true);
		}
	 // Fin nouvOuvrage	
			
	
	/**
	 * Création d'un périodique 
	 * Invoqué dans VueSaisiePeriodique
	 * @param issn du périodique et son nom 
	 * affiche un message de confirmation après l'enregistrement ou un message d'erreur 
	 */
	public void nouvPeriodique(String issn, String nomp) 
	{
		// vérification de la présence de l'issn et du nom
		if ((issn.length() == 0) || (nomp.length() == 0))
		{
				Message dialog = new Message("Tous les champs sont obligatoires");
				dialog.setVisible(true);
		}
		else 
		{
			Periodique periodique = getPeriodique(issn);
			if (periodique == null)
			{
				// Instanciation du periodique
				periodique = new Periodique(issn, nomp);
				// Ajout de ce periodique dans l'ensemble des periodiques de la bibliothèque
				this.setPeriodique(periodique, issn);
				
				Message dialog = new Message("Periodique enregistré");
				dialog.setVisible(true);
				this.getVueSaisiePeriodique().setEtat(Vue.inter1);
				
			}
			else
			{
				Message dialog = new Message("un périodique avec cet issn existe déjà");
				dialog.setVisible(true);
				this.getVueSaisiePeriodique().setEtat(Vue.initiale);
			}
		}
	}

	public Parution nouvParution(String issn, String numero, HashSet<Article> articles) {
		// vérification de la présence des infos obligatoires et du format de la date
		if (issn.length() == 0 || numero.length() == 0 || articles.isEmpty()){
				Message dialog1 = new Message("Impossible de créer la parution");
				dialog1.setVisible(true);
				this.getVueSaisieParution().setEtat(Vue.finale);
				System.out.println("retourne null");
				return null;
		}					
		else{
				Parution paruExistante=this.getParu(issn, numero);
					if(paruExistante==null)
					{
						Parution paru = new Parution(Integer.parseInt(numero) , articles);
						Periodique p = this.getPeriodique(issn);
						Message dialog2 = new Message("Parution enregistré");
						dialog2.setVisible(true);
						if (this.getVueSaisieParution() != null)
							this.getVueSaisieParution().setEtat(Vue.finale);
						else if (this.getVueSaisiePeriodique() != null)
							this.getVueSaisiePeriodique().setEtat(Vue.finale);
						paru.setPeriodique(p);
						p.setParution(paru);
						if (this.getVueSaisieParution() != null)
							this.getVueSaisieParution().setEtat(Vue.finale);
						else if (this.getVueSaisiePeriodique() != null)
							this.getVueSaisiePeriodique().setEtat(Vue.finale);
						
						return paru;
					}
					else
					{
						Message dialog3 = new Message("Parution déjà présente pour ce numéro de parution");
						dialog3.setVisible(true);
						return null;
					}
			}
	}
	
	public Auteur nouvAuteur(String nom, String prenom){
		return new Auteur(nom,prenom);
	}	

	public Article nouvArticle(String titre, String premPage, HashSet<Auteur> auteurs, HashSet<MotsCles> motcles){
		if ((titre.length() == 0) || (premPage.length() == 0) || auteurs.isEmpty() || motcles.isEmpty()){
			Message dialog = new Message("Impossible de créer l'article convenablement");
			dialog.setVisible(true);
			this.getVueSaisieParution().setEtat(Vue.inter2);
			return null;
		}
		else
		{
			Article a = new Article(titre, Integer.parseInt(premPage), auteurs, motcles);
			Message dialog = new Message("L'article a été correctement ajouté");
			dialog.setVisible(true);
			if (this.getVueSaisieParution()!= null)
			{
				this.getVueSaisieParution().setEtat(Vue.inter2);
			}
			else if (this.getVueSaisiePeriodique()!= null)
			{
				this.getVueSaisiePeriodique().setEtat(Vue.inter2);
			}
			System.out.println(auteurs.toString());
			System.out.println(motcles.toString());
			Iterator it = auteurs.iterator();
			while(it.hasNext()){
			//liaison de l'article pour chaque auteur
				((Auteur) it.next()).setArticle(a);
			}		
			Iterator itrMot = motcles.iterator();
			while(itrMot.hasNext()){
			//liaison de l'article pour chaque motCles	
				((MotsCles) itrMot.next()).setArticle(a);
			}
			
			return a;
		}	
	}
	
	public void alimenteListParution(String issn){
		//ensemble de parution pour la liste de parutions d'un périodique
		HashSet<Parution> parutions= new HashSet<Parution>(); 
		parutions = getParutions(issn);
		if (this.getVueConsultPeriodique()!=null){
			Iterator itr = parutions.iterator();
			if (itr.hasNext()){
				while (itr.hasNext()){
					this.getVueConsultPeriodique().alimente((Parution)itr.next());
				}
			}
			else{
				Message dialog = new Message("Il n'existe aucune parution pour ce Périodique");
				dialog.setVisible(true);
				this.getVueConsultPeriodique().setEtat(Vue.initiale);
			}
		}
	}	
	
	public void alimenteListArticle(String issn, String numeroParution){
		HashSet<Article> articles= new HashSet<Article>(); 
		articles = getArticles(getParutions(issn), numeroParution);
		if (this.getVueConsultPeriodique()!=null){
			Iterator itr = articles.iterator();
			if (itr.hasNext()){
				while (itr.hasNext()){
					this.getVueConsultPeriodique().alimente((Article)itr.next());
				}
			}
			else{
				Message dialog = new Message("Il n'existe aucune parution pour ce Périodique");
				dialog.setVisible(true);
				this.getVueConsultPeriodique().setEtat(Vue.inter1);
			}
		}
		}
	
	public void alimenteInfosArticle(String issn, String numeroParution, String titre){
		HashSet<Auteur> auteurs= new HashSet<Auteur>(); 
		HashSet<MotsCles> mots= new HashSet<MotsCles>();
		Article art;
		art = getArticle(getArticles(getParutions(issn), numeroParution), titre);
		int numero = art.getPage();
		this.getVueConsultPeriodique().alimenteNumPage(Integer.toString(numero));
		auteurs = art.getAuteurs();
		System.out.println(auteurs.toString());
		mots = art.getMotCles();
		System.out.println(mots.toString());
		Iterator itrAuteurs = auteurs.iterator();
		while (itrAuteurs.hasNext()){
			String nom;
			String prenom;
			Auteur a = (Auteur)itrAuteurs.next();
			nom = a.getNom();
			prenom = a.getPrenom();
			System.out.println("#############" + nom + " " + prenom + "#############");
			this.getVueConsultPeriodique().alimenteAuteurs(nom, prenom);
		}
		Iterator itrMotCles = mots.iterator();
		while (itrMotCles.hasNext()){
			String motString;
			MotsCles mot = (MotsCles)itrMotCles.next();
			motString = mot.getMot();
			this.getVueConsultPeriodique().alimenteMotCles(motString);
		}
	}
	
	
	public HashSet<Parution> getParutions(String issn){
		Periodique period = this.getPeriodique(issn);
		HashSet<Parution> parutions = new HashSet<Parution>();
		parutions = period.getParutions();
		return parutions;
	}	
	
	public HashSet<Article> getArticles(HashSet<Parution> p, String numeroParution){
		Iterator itr = p.iterator();
		while (itr.hasNext()){
			Parution paru = (Parution)itr.next();
			if (paru.getNumero()==Integer.parseInt(numeroParution)){
				return paru.getArticles();
			}
		}
		HashSet<Article> arts = new HashSet<Article>();
		return arts;
	}
	
	public Article getArticle(HashSet<Article> arts, String titre){
		Iterator itr = arts.iterator();
		while (itr.hasNext()){
			Article a = (Article)itr.next();
			if (a.getTitre()==titre){
				return a;
			}
		}
		return null;
	}
};
	
		
		